# coding:utf-8
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# 柯里化一个print
printn = lambda *x: print(*x, sep='\n')

# 层次化索引
'''
它使你能在⼀个轴上拥有多个（两个以上）索引级别。抽象点说，它使你能以低维度形式处理⾼维度数据。
'''


# 先来看⼀个简单的例⼦：创建⼀个Series，并⽤⼀个由列表或数组组成的列表作为索引
def testhindex():
    data = pd.Series(
        np.random.randn(9),
        index=[
            ['a', 'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd'],
            [1, 2, 3, 1, 3, 1, 2, 2, 3]
        ])
    # 结果是经过美化的带有MultiIndex索引的Series的格式。索引之间的“间隔”表示“直接使⽤上⾯的标签”
    printn("multiindex索引结果:", data)
    printn("multiindex标签:", data.index)
    # 对于⼀个层次化索引的对象，可以使⽤所谓的部分索引，使⽤它选取数据⼦集的操作更简单
    printn(data['b'], data['b':'c'], data.loc[['b', 'd']])
    # 有时甚⾄还可以在“内层”中进⾏选取：
    printn('内层索引:', data.loc[:, 2])

    # 层次化索引在数据重塑和基于分组的操作（如透视表⽣成）中扮演着重要的⻆⾊。例如，可以通过unstack⽅法将这段Series数据重新安排到⼀个DataFrame中
    s = data.unstack()
    printn("unstack方法:", s)
    # unstack的逆运算是stack：
    printn("stack方法:", data.unstack().stack())

    # 对于⼀个DataFrame，每条轴都可以有分层索引
    frame = pd.DataFrame(
        np.arange(12).reshape((4, 3)),
        index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]],
        columns=[['Ohio', 'Ohio', 'Colorado'], ['Green', 'Red', 'Green']])
    printn("分层索引:", frame)
    # 各层都可以有名字（可以是字符串，也可以是别的Python对象）。如果指定了名称，它们就会显示在控制台输出
    frame.index.names = ['key1', 'key2']
    frame.columns.names = ['state', 'color']
    printn("每层名字:", frame)
    # 有了部分列索引，因此可以轻松选取列分组
    printn('选取列分组:', frame['Ohio'])

    # 可以单独创建MultiIndex然后复⽤。上⾯那个DataFrame中的（带有分级名称）列可以这样创建
    s = pd.MultiIndex.from_arrays(
        [['Ohio', 'Ohio', 'Colorado'], ['Green', 'Red', 'Green']],
        names=['state', 'color'])
    printn("多级标签对象:", s)
# testhindex()


# 重排与分级，根据级别汇总统计
def testreoder():
    '''
    需要重新调整某条轴上各级别的顺序，或根据指定级别上的值对数据进⾏排序。
    '''
    frame = pd.DataFrame(
        np.arange(12).reshape((4, 3)),
        index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]],
        columns=[['Ohio', 'Ohio', 'Colorado'], ['Green', 'Red', 'Green']])
    frame.index.names = ['key1', 'key2']
    frame.columns.names = ['state', 'color']
    # swaplevel接受两个级别编号或名称，并返回⼀个互换了级别的新对象(但数据不会发⽣变化)
    s = frame.swaplevel('key1', 'key2')
    printn("swaplevel方法:", s)
    # sort_index则根据单个级别中的值对数据进⾏排序。
    # 交换级别时，常常也会⽤到sort_index，这样最终结果就是按照指定顺序进⾏字⺟排序了
    s1 = frame.sort_index(level=1)
    printn("sort_index方法:", s1)
    s2 = frame.swaplevel(0, 1).sort_index(level=0)
    printn("swaplevel和sort_index方法:", s2)

    # 许多对DataFrame和Series的描述和汇总统计都有⼀个level选项，它⽤于指定在某条轴上求和的级别
    s3 = frame.sum(level='key2')
    printn("统计1：", s3)
    s4 = frame.sum(level='color', axis=1)
    printn("统计2：", s4)
# testreoder()


# 使⽤DataFrame的列进⾏索引--set_index函数，索引回归列用reset_index()
# ⼈们经常想要将DataFrame的⼀个或多个列当做⾏索引来⽤，或者可能希望将⾏索引变成DataFrame的列
def testrl():
    frame = pd.DataFrame(
        {
            'a': range(7),
            'b': range(7, 0, -1),
            'c': ['one', 'one', 'one', 'two', 'two', 'two', 'two'],
            'd': [0, 1, 2, 0, 1, 2, 3]
        })
    printn("原始数据:", frame)
    # DataFrame的set_index函数会将其⼀个或多个列转换为⾏索引，并创建⼀个新的DataFrame
    frame2 = frame.set_index(['c', 'd'])
    printn("转换为行索引:", frame2)

    # 默认情况下，那些列会从DataFrame中移除，但也可以将其保留下来
    s = frame.set_index(['c', 'd'], drop=False)
    printn("保留成为索引的列:", s)

    # reset_index的功能跟set_index刚好相反，层次化索引的级别会被转移到列⾥⾯
    s1 = frame2.reset_index()
    printn("reset_index方法:", s1)
# testrl()


# 合并数据集
'''
pandas对象中的数据可以通过⼀些⽅式进⾏合并：
    pandas.merge可根据⼀个或多个键将不同DataFrame中的⾏连接起来。SQL或其他关系型数据库的⽤户对此应该会⽐较熟悉，因为它实现的就是数据库的join操作。
    pandas.concat可以沿着⼀条轴将多个对象堆叠到⼀起。
    实例⽅法combine_first可以将重复数据拼接在⼀起，⽤⼀个对象中的值填充另⼀个对象中的缺失值
'''


# 数据库风格的DataFrame合并
# 数据集的合并（merge）或连接（join）运算是通过⼀个或多个键将⾏连接起来的。这些运算是关系型数据库（基于SQL）的核⼼
# 默认情况下，merge做的是“内连接”；结果中的键是交集。其他⽅式还有"left"、"right"以及"outer"。外连接求取的是键的并集，组合了左连接和右连接的效果。inner使用两表都有的键，left--使用左表的键，rigth-右表，outer--两表所有的键。
def testMerge():
    '''
    merge参数说明：left--参与合并的左侧DataFrame；同理rigth
    how--"inner","outer","left","right"其中之一，默认inner。
    on--用于连接的黎明。必须存在于左右两个DataFrame对象中。如果未指定，且其他连接键也未指定，则以left和right列名的交集作为连接键
    left_on--左侧DataFrame中用作连接键的列，同理right_on
    left_index--将左侧的行索引用作其连接键，同理right_index
    sort--根据连接键对合并后的数据进行排序，默认True。有时处理大数据集时，禁用该选项可获得更好的性能
    suffixes--字符串值元组，用于追加到重叠列名的末尾，默认为("_x","_y")。
    copy--设置为False，可以在某些特殊情况下避免将数据复制到结果数据结构中。默认总是复制。
    '''
    df1 = pd.DataFrame(
        {'key': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
         'data1': range(7)})
    df2 = pd.DataFrame({'key': ['a', 'b', 'd'], 'data2': range(3)})
    printn("df1:", df1, "df2:", df2)
    # 多对⼀的合并。df1中的数据有多个被标记为a和b的⾏，⽽df2中key列的每个值则仅对应⼀⾏。对这些对象调⽤merge即可得到
    # 以下并没有指明要⽤哪个列进⾏连接。如果没有指定，merge就会将重叠列的列名当做键
    s = pd.merge(df1, df2)
    printn("merge结果:", s)
    # 指明连接列
    s1 = pd.merge(df1, df2, on='key')
    printn("merge结果2:", s1)

    # 如果两个对象的列名不同，也可以分别进⾏指定
    df3 = pd.DataFrame(
        {'lkey': ['b', 'b', 'a', 'c', 'a', 'a', 'b'],
         'data1': range(7)})
    df4 = pd.DataFrame({'rkey': ['a', 'b', 'd'], 'data2': range(3)})
    s2 = pd.merge(df3, df4, left_on='lkey', right_on='rkey')
    printn("merge结果3:", s2)

    # 外连接
    s3 = pd.merge(df1, df2, how='outer')
    printn("外连接:", s3)

    # 多对多的合并不直观
    df1 = pd.DataFrame(
        {'key': ['b', 'b', 'a', 'c', 'a', 'b'],
         'data1': range(6)})
    df2 = pd.DataFrame({'key': ['a', 'b', 'a', 'b', 'd'], 'data2': range(5)})
    printn("df1:", df1, "df2:", df2)
    # 多对多连接产⽣的是⾏的笛卡尔积。由于左边的DataFrame有3个"b"⾏，右边的有2个，所以最终结果中就有6个"b"⾏。
    s4 = pd.merge(df1, df2, on='key', how='left')
    printn("多对多合并:", s4)
    # 连接⽅式只影响出现在结果中的不同的键的值
    s5 = pd.merge(df1, df2, how='inner')
    printn("多对多合并2:", s5)

    # 要根据多个键进⾏合并，传⼊⼀个由列名组成的列表即可：
    left = pd.DataFrame(
        {
            'key1': ['foo', 'foo', 'bar'],
            'key2': ['one', 'two', 'one'],
            'lval': [1, 2, 3]
        })
    right = pd.DataFrame(
        {
            'key1': ['foo', 'foo', 'bar', 'bar'],
            'key2': ['one', 'one', 'one', 'two'],
            'rval': [4, 5, 6, 7]
        })
    s6 = pd.merge(left, right, on=['key1', 'key2'], how='outer')
    printn("多对多合并3:", s6)
    '''
    可以这样来理解：多个键形成⼀系列元组，并将其当做单个连接键（当然，实际上并不是这么回事）。
    '''
    # 对重复列名的处理，merge有⼀个更实⽤的suffixes选项，⽤于指定附加到左右两个DataFrame对象的重叠列名上的字符串：
    s7 = pd.merge(left, right, on='key1')
    printn("不指定suffixes:", s7)
    s8 = pd.merge(left, right, on='key1', suffixes=('_left', '_right'))
    printn("指定suffixes:", s8)


testMerge()


# 索引上的合并--最方便的索引合并是join，merge用处更广泛
# 有时候，DataFrame中的连接键位于其索引中。
# 在这种情况下，你可以传⼊left_index=True或right_index=True（或两个都传）以说明索引应该被⽤作连接键
def testindexmerge():
    left1 = pd.DataFrame(
        {'key': ['a', 'b', 'a', 'a', 'b', 'c'],
         'value': range(6)})
    right1 = pd.DataFrame({'group_val': [3.5, 7]}, index=['a', 'b'])
    printn("left1:", left1, "right1:", right1)
    # 右侧的索引作为连接键
    s = pd.merge(left1, right1, left_on='key', right_index=True)
    printn("索引合并:", s)

    # 由于默认的merge⽅法是求取连接键的交集，因此你可以通过外连接的⽅式得到它们的并集：
    s2 = pd.merge(left1, right1, left_on='key', right_index=True, how='outer')
    printn("外连接并集:", s2)

    # 对于层次化索引的数据，事情就有点复杂了，因为索引的合并默认是多键合并
    lefth = pd.DataFrame(
        {
            'key1': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
            'key2': [2000, 2001, 2002, 2001, 2002],
            'data': np.arange(5.)
        })
    righth = pd.DataFrame(
        np.arange(12).reshape((6, 2)),
        index=[
            ['Nevada', 'Nevada', 'Ohio', 'Ohio', 'Ohio', 'Ohio'],
            [2001, 2000, 2000, 2000, 2001, 2002]
        ],
        columns=['event1', 'event2'])
    printn("lefth:", lefth, "righth:", righth)
    # 这种情况下，你必须以列表的形式指明⽤作合并键的多个列（注意⽤how='outer'对重复索引值的处理）：
    s3 = pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index=True)
    printn("指明合并列:", s3)
    s4 = pd.merge(
        lefth,
        righth,
        left_on=['key1', 'key2'],
        right_index=True,
        how='outer')
    printn("指明合并列2:", s4)

    # 同时使⽤合并双⽅的索引也没问题：
    left2 = pd.DataFrame(
        [[1., 2.], [3., 4.], [5., 6.]],
        index=['a', 'c', 'e'],
        columns=['Ohio', 'Nevada'])
    right2 = pd.DataFrame(
        [[7., 8.], [9., 10.], [11., 12.], [13, 14]],
        index=['b', 'c', 'd', 'e'],
        columns=['Missouri', 'Alabama'])
    printn("left2:", left2, "right2:", right2)
    s5 = pd.merge(
        left2, right2,
        how='outer',
        left_index=True,
        right_index=True)
    printn("合并双方索引:", s5)

    # DataFrame还有⼀个便捷的join实例⽅法，它能更为⽅便地实现按索引合并。
    # 它还可⽤于合并多个带有相同或相似索引的DataFrame对象，但要求没有重叠的列
    s6 = left2.join(right2, how='outer')
    printn("join方法:", s6)
    # DataFrame的join⽅法默认使⽤的是左连接，保留左边表的⾏索引。
    # 它还⽀持在调⽤的DataFrame的列上，连接传递的DataFrame索引
    s7 = left1.join(right1, on='key')
    printn("join方法2:", s7)

    # 对于简单的索引合并，你还可以向join传⼊⼀组DataFrame
    another = pd.DataFrame(
        [[7., 8.], [9., 10.], [11., 12.], [16., 17.]],
        index=['a', 'c', 'e', 'f'],
        columns=['NewYork', 'Oregon'])
    printn("another:", another)
    s8 = left2.join([right2, another])
    printn("join方法3:", s8)
    s9 = left2.join([right2, another], how='outer')
    printn("join方法4:", s9)
# testindexmerge()


# 轴向连接
# 另⼀种数据合并运算也被称作连接（concatenation）、绑定（binding）或堆叠（stacking）。
# NumPy的concatenation函数可以⽤NumPy数组来做
def testNumpyConcatenation():
    arr = np.arange(12).reshape((3, 4))
    printn('numpy数组:', arr)
    s = np.concatenate([arr, arr], axis=1)
    printn("NumPy的concatenation:", s)


# testNumpyConcatenation()
'''
    对于pandas对象（如Series和DataFrame），带有标签的轴使你能够进⼀步推⼴数组的连接运算。具体点说，你还需要考虑以下这些东⻄：
    如果对象在其它轴上的索引不同，我们应该合并这些轴的不同元素还是只使⽤交集？
    连接的数据集是否需要在结果对象中可识别？
    连接轴中保存的数据是否需要保留？许多情况下，DataFrame默认的整数标签最好在连接时删掉。
'''
'''
参数说明：objs--参与连接的pandas对象的列表或字典。唯一必需的参数
axis--指明连接的轴向，默认0
join--"inner"、"outer"其中之一，默认"outer"。指明其他轴向上的索引是按交集还是并集进行
keys--与连接对象有关的值，用于形成连接轴向上的层次化索引。可以是任意值的列表或数组、元组数组、数组列表(如果levels设置成多级数组的话)
levels--指定用作层次化索引各级别上的索引，如果设置了keys的话。
names--用于创建分层级的名称，如果设置了keys和(或)levels的话
verify_integrity--检查结果对象新轴上的重复情况，如果发现则引发异常。默认False允许重复
ignore_index--不保留连接轴上的索引，产生一组新索引range(total_length)
'''


def testconcat():
    # 假设有三个没有重叠索引的Series
    s1 = pd.Series([0, 1], index=['a', 'b'])
    s2 = pd.Series([2, 3, 4], index=['c', 'd', 'e'])
    s3 = pd.Series([5, 6], index=['f', 'g'])
    # 对这些对象调⽤concat可以将值和索引粘合在⼀起
    ss1 = pd.concat([s1, s2, s3])
    printn("concat方法:", ss1)

    # 默认情况下，concat是在axis=0上⼯作的，最终产⽣⼀个新的Series。如果传⼊axis=1，则结果就会变成⼀个DataFrame（axis=1是列）：
    ss2 = pd.concat([s1, s2, s3], axis=1)
    printn("concat方法2:", ss2)
    # 这种情况下，另外的轴上没有重叠，从索引的有序并集（外连接）上就可以看出来。传⼊join='inner'即可得到它们的交集：
    s4 = pd.concat([s1, s3])
    printn("concat方法3:", s4)
    ss3 = pd.concat([s1, s4], axis=1)
    printn("concat方法4:", ss3)
    ss4 = pd.concat([s1, s4], axis=1, join='inner')
    printn("concat方法5:", ss4)
    # 可以通过reindex指定要在其它轴上使⽤的索引
    ss5 = pd.concat([s1, s4], axis=1).reindex(['a', 'c', 'b', 'e'])
    printn("concat方法6:", ss5)

    # 假设你想要在连接轴上创建⼀个层次化索引。使⽤keys参数即可达到这个⽬的
    result = pd.concat([s1, s1, s3], keys=['one', 'two', 'three'])
    printn("创建层次化索引:", result)
    printn("result使用unstack后:", result.unstack())
    # 如果沿着axis=1对Series进⾏合并，则keys就会成为DataFrame的列头
    ss6 = pd.concat([s1, s2, s3], axis=1, keys=['one', 'two', 'three'])
    printn("concat方法7:", ss6)

    # 同样的逻辑也适⽤于DataFrame对象：
    df1 = pd.DataFrame(
        np.arange(6).reshape(3, 2),
        index=['a', 'b', 'c'],
        columns=['one', 'two'])
    df2 = pd.DataFrame(
        5 + np.arange(4).reshape(2, 2),
        index=['a', 'c'],
        columns=['three', 'four'])
    print("df1:\n", df1)
    print("df2:\n", df2)
    ss7 = pd.concat([df1, df2], axis=1, keys=['level1', 'level2'], sort=True)
    print("concat方法8:\n", ss7)
    # 如果传⼊的不是列表⽽是⼀个字典，则字典的键就会被当做keys选项的值
    ss8 = pd.concat({'level1': df1, 'level2': df2}, axis=1, sort=True)
    print("concat方法9:\n", ss8)

    # 此外还有两个⽤于管理层次化索引创建⽅式的参数（参⻅表8-3）。举个例⼦，我们可以⽤names参数命名创建的轴级别：
    ss9 = pd.concat(
        [df1, df2],
        axis=1,
        keys=['level1', 'level2'],
        names=['upper', 'lower'],
        sort=True)
    print("concat方法10:\n", ss9)

    # DataFrame的⾏索引不包含任何相关数据,传⼊ignore_index=True即可
    df1 = pd.DataFrame(np.random.randn(3, 4), columns=['a', 'b', 'c', 'd'])
    df2 = pd.DataFrame(np.random.randn(2, 3), columns=['b', 'd', 'a'])
    printn("df1:", df1, "df2:", df2)
    ss10 = pd.concat([df1, df2], ignore_index=True)
    printn("concat方法11:", ss10)
# testconcat()


# 合并重叠数据
# 还有⼀种数据组合问题不能⽤简单的合并（merge）或连接（concatenation）运算来处理
# ⽐如说，你可能有索引全部或部分重叠的两个数据集。举个有启发性的例⼦，我们使⽤NumPy的where函数，它表示⼀种等价于⾯向数组的if-else
def testoverlap():
    a = pd.Series(
        [np.nan, 2.5, np.nan, 3.5, 4.5, np.nan],
        index=['f', 'e', 'd', 'c', 'b', 'a'])
    b = pd.Series(
        np.arange(
            len(a), dtype=np.float64),
        index=['f', 'e', 'd', 'c', 'b', 'a'])
    b[-1] = np.nan
    printn("a:", a, "b:", b)
    s = np.where(pd.isnull(a), b, a)
    printn("结果1:", s)

    # Series有⼀个combine_first⽅法，实现的也是⼀样的功能，还带有pandas的数据对⻬
    s1 = b[:-2].combine_first(a[2:])
    printn("combine_first⽅法:", s1)

    # 对于DataFrame，combine_first⾃然也会在列上做同样的事情，因此你可以将其看做：⽤传递对象中的数据为调⽤对象的缺失数据“打补丁”：
    df1 = pd.DataFrame(
        {
            'a': [1., np.nan, 5., np.nan],
            'b': [np.nan, 2., np.nan, 6.],
            'c': range(2, 18, 4)
        })
    df2 = pd.DataFrame(
        {'a': [5., 4., np.nan, 3., 7.],
         'b': [np.nan, 3., 4., 6., 8.]})
    printn("df1:", df1, "df2:", df2)
    s2 = df1.combine_first(df2)
    printn("DataFrame的combine_first⽅法:", s2)
# testoverlap()


# 重塑和轴向旋转--有许多⽤于重新排列表格型数据的基础运算。这些函数也称作重塑（reshape）或轴向旋转（pivot）运算
# 重塑层次化索引
'''
层次化索引为DataFrame数据的重排任务提供了⼀种具有良好⼀致性的⽅式。主要功能有⼆：
stack：将数据的列“旋转”为⾏。
unstack：将数据的⾏“旋转”为列。
'''


def testreshape():
    data = pd.DataFrame(
        np.arange(6).reshape((2, 3)),
        index=pd.Index(['Ohio', 'Colorado'], name='state'),
        columns=pd.Index(['one', 'two', 'three'],
                         name='number'))
    printn("原数据:", data)
    # 对该数据使⽤stack⽅法即可将列转换为⾏，得到⼀个Series
    result = data.stack()
    printn("stack方法:", result)
    # 对于⼀个层次化索引的Series，你可以⽤unstack将其重排为⼀个DataFrame
    ss1 = result.unstack()
    printn("unstack方法:", ss1)
    # 默认情况下，unstack操作的是最内层（stack也是如此）。传⼊分层级别的编号或名称即可对其它级别进⾏unstack操作
    printn("stack方法2:", result.unstack(0))
    printn("unstack方法2:", result.unstack('state'))

    # 如果不是所有的级别值都能在各分组中找到的话，则unstack操作可能会引⼊缺失数据：
    s1 = pd.Series([0, 1, 2, 3], index=['a', 'b', 'c', 'd'])
    s2 = pd.Series([4, 5, 6], index=['c', 'd', 'e'])
    data2 = pd.concat([s1, s2], keys=['one', 'two'])
    printn("concat后:", data2)
    printn("再次unstack后:", data2.unstack())
    # stack默认会滤除缺失数据，因此该运算是可逆的：
    printn("默认值:", data2.unstack().stack())
    printn("不过滤NA:", data2.unstack().stack(dropna=False))

    # 在对DataFrame进⾏unstack操作时，作为旋转轴的级别将会成为结果中的最低级别：
    df = pd.DataFrame(
        {'left': result,
         'right': result + 5},
        columns=pd.Index(['left', 'right'], name='side'))
    printn("df:", df)
    printn("DataFrame的unstack方法:", df.unstack('state'))

    # 当调⽤stack，我们可以指明轴的名字：
    printn("指定轴名后:", df.unstack('state').stack('side'))
# testreshape()


# 将“⻓格式”旋转为“宽格式”
# 多个时间序列数据通常是以所谓的“⻓格式”（long）或“堆叠格式”（stacked）存储在数据库和CSV中的
def longtowide():
    data = pd.read_csv('examples/macrodata.csv')
    printn('前5行:', data.head())
    periods = pd.PeriodIndex(year=data.year, quarter=data.quarter, name='date')
    columns = pd.Index(['realgdp', 'infl', 'unemp'], name='item')
    data = data.reindex(columns=columns)
    data.index = periods.to_timestamp('D', 'end')
    # 这就是多个时间序列（或者其它带有两个或多个键的可观察数据，这⾥，我们的键是date和item）的⻓格
    ldata = data.stack().reset_index().rename(columns={0: 'value'})
    printn("长数据前10行:", ldata[:10])
    '''
    关系型数据库（如MySQL）中的数据经常都是这样存储的，因为固定架构（即列名和数据类型）有⼀
    个好处：随着表中数据的添加，item列中的值的种类能够增加。在前⾯的例⼦中，date和item通常就是
    主键（⽤关系型数据库的说法），不仅提供了关系完整性，⽽且提供了更为简单的查询⽀持。有的情
    况下，使⽤这样的数据会很麻烦，你可能会更喜欢DataFrame，不同的item值分别形成⼀列，date列
    中的时间戳则⽤作索引。DataFrame的pivot⽅法完全可以实现这个转换
    '''
    # 前两个传递的值分别⽤作⾏和列索引，最后⼀个可选值则是⽤于填充DataFrame的数据列
    pivoted = ldata.pivot('date', 'item', 'value')
    printn("转换后:", pivoted)

    # 假设有两个需要同时重塑的数据列：
    ldata['value2'] = np.random.randn(len(ldata))
    printn("更新后:", ldata[:10])
    # 如果忽略最后⼀个参数，得到的DataFrame就会带有层次化的列
    pivoted = ldata.pivot('date', 'item')
    printn("转换后2:", pivoted[:5])
    printn("转换后3:", pivoted['value'][:5])

    # pivot其实就是⽤set_index创建层次化索引，再⽤unstack重塑
    unstacked = ldata.set_index(['date', 'item']).unstack('item')
    printn("pivot的实际方法:", unstacked[:7])
# longtowide()


# 将“宽格式”旋转为“⻓格式”
# 旋转DataFrame的逆运算是pandas.melt。它不是将⼀列转换到多个新的DataFrame，⽽是合并多个列成为⼀个，产⽣⼀个⽐输⼊⻓的DataFrame
def widetolong():
    df = pd.DataFrame(
        {
            'key': ['foo', 'bar', 'baz'],
            'A': [1, 2, 3],
            'B': [4, 5, 6],
            'C': [7, 8, 9]
        })
    printn('df', df)
    # key列可能是分组指标，其它的列是数据值。当使⽤pandas.melt，我们必须指明哪些列是分组指标。
    melted = pd.melt(df, ['key'])
    printn("melted方法:", melted)
    # 使⽤pivot，可以重塑回原来的样⼦
    reshaped = melted.pivot('key', 'variable', 'value')
    printn("重塑回来:", reshaped)
    # 因为pivot的结果从列创建了⼀个索引，⽤作⾏标签，我们可以使⽤reset_index将数据移回列
    reshaped2 = reshaped.reset_index()
    printn("重塑回来2:", reshaped2)

    # 还可以指定列的⼦集，作为值的列
    s = pd.melt(df, id_vars=['key'], value_vars=['A', 'B'])
    printn("子集例子:", s)
    # pandas.melt也可以不⽤分组指标
    s1 = pd.melt(df, value_vars=['A', 'B', 'C'])
    printn("不用分组指标1:", s1)
    s2 = pd.melt(df, value_vars=['key', 'A', 'B'])
    printn("不用分组指标2:", s2)
# widetolong()
